const express = require('express');
const router = express.Router();
const User = require('../models/User');

// 引入mongoose用于ObjectId校验
const mongoose = require('mongoose');

// 移除JWT相关依赖和配置

// 移除鉴权中间件定义

// 1. 用户注册接口（客户/管理员创建用户）
router.post('/register', async (req, res) => {
  try {
    const { account, password, name, address, phone } = req.body;
    // console.log(req.body,role);
    const role = 0;
    // 校验必填字段（移除对role的强制校验）
    if (!account || !password || !name || !address || !phone) {
      return res.status(400).json({ code: 400, message: '账号、密码、姓名、地址、手机号为必填字段' });
    }

    // 检查账号是否已存在
    const existingUser = await User.findOne({ account });
    if (existingUser) {
      return res.status(409).json({ code: 409, message: '账号已存在' });
    }

    // 创建用户（未传role时自动使用模型默认值0）
    const newUser = new User({ account, password, name, role, address, phone });
    await newUser.save();
    
    res.status(201).json({ code: 201, message: '用户创建成功', data: { userId: newUser._id } });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});

// 2. 用户登录接口（不再返回token）
router.post('/login', async (req, res) => {
  try {
    const { account, password } = req.body;
    const user = await User.findOne({ account }).select('+password'); // 强制查询密码字段
    
    if (!user) {
      return res.status(401).json({ code: 401, message: '账号不存在' });
    }

    const isMatch = user.password == password;
    if (!isMatch) {
      return res.status(401).json({ code: 401, message: '密码错误' });
    }

    // 移除JWT令牌生成逻辑
    res.json({ code: 200, message: '登录成功', data: { 
      user: { 
        _id: user._id,
        account: user.account,
        name: user.name,
        role: user.role,
        phone: user.phone,
        address: user.address
      }
    }});
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});

// 3. 获取当前用户信息（移除鉴权中间件）
router.get('/me', async (req, res) => {
  try {
    // 从查询参数中获取id，并映射为userId变量
    const { id: userId } = req.query; 
    
    // 校验用户ID是否存在
    if (!userId) {
      return res.status(400).json({ code: 400, message: '用户ID未提供' });
    }

    // 校验用户ID是否为有效的MongoDB ObjectId
    if (!mongoose.Types.ObjectId.isValid(userId)) {
      return res.status(400).json({ code: 400, message: '无效的用户ID格式' });
    }

    // 使用正确的userId变量查询用户
    const user = await User.findById(userId).select('-password');
    if (!user) {
      return res.status(404).json({ code: 404, message: '用户不存在' });
    }
    res.json({ code: 200, data: user });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});

// 4. 更新用户信息（移除鉴权中间件）
router.put('/me', async (req, res) => {
  try {
    const { userId, name, address, phone } = req.body; // 需通过请求传递用户ID
    const updatedUser = await User.findByIdAndUpdate(
      userId,
      { name, address, phone },
      { new: true } // 返回更新后的文档
    );
    res.json({ code: 200, data: updatedUser });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});

// 5. 管理员获取所有用户列表（移除鉴权中间件）
router.get('/all', async (req, res) => {
  try {
    const users = await User.find().select('-password'); // 排除密码字段
    res.json({ code: 200, data: users });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});

// 6. 获取客户列表（移除鉴权中间件）
router.get('/customers', async (req, res) => {
  try {
    const customers = await User.find({ role: 0 }).select('-password');
    res.json({ code: 200, data: customers });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});

// 7. 获取客服列表（移除鉴权中间件）
router.get('/staffs', async (req, res) => {
  try {
    const staffs = await User.find({ role: 1 }).select('-password');
    res.json({ code: 200, data: staffs });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});

// 8. 获取站点列表（移除鉴权中间件）
router.get('/stations', async (req, res) => {
  try {
    const stations = await User.find({ role: 2 }).select('-password');
    res.json({ code: 200, data: stations });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});

// 9. 获取维修员列表（移除鉴权中间件）
router.get('/repairmen', async (req, res) => {
  try {
    const repairmen = await User.find({ role: 3 }).select('-password');
    res.json({ code: 200, data: repairmen });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});

// 10. 更改用户权限接口（移除鉴权中间件）
router.put('/update-role', async (req, res) => {
  try {
    const { userId, newRole } = req.body;
    
    // 校验必填参数
    if (!userId || !newRole) {
      return res.status(400).json({ code: 400, message: '用户ID和新角色为必填字段' });
    }

    // 校验角色值有效性（与User模型的enum一致）
    if (![0, 1, 2, 3, 4].includes(newRole)) {
      return res.status(400).json({ code: 400, message: '角色值必须为 0（客户）、1（客服）、2（站点）、3（维修员）、4（管理员）' });
    }

    // 查找并更新用户角色
    const updatedUser = await User.findByIdAndUpdate(
      userId,
      { role: newRole },
      { new: true, select: '-password' } // 返回更新后的文档并排除密码字段
    );

    if (!updatedUser) {
      return res.status(404).json({ code: 404, message: '目标用户不存在' });
    }

    // 新增：查找并更新对应的权限申请单状态
    const pendingApplication = await Application.findOne({
      user_id: userId,
      applied_role: newRole,
      application_type: 'role_upgrade',
      status: '待审核'
    });

    if (pendingApplication) {
      pendingApplication.status = '已通过';
      await pendingApplication.save();
    }

    res.json({ 
      code: 200, 
      message: '用户权限更新成功', 
      data: { 
        user: updatedUser,
        application: pendingApplication ? '已同步更新对应权限申请单为"已通过"' : '无待审核的权限申请单需要更新'
      } 
    });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});

const Application = require('../models/Application'); // 新增：引入申请单模型

// 11. 权限申请接口（用户提交权限申请）
router.post('/applications', async (req, res) => {
  try {
    const { user_id, applied_role } = req.body;

    // 校验必填参数
    if (!user_id || !applied_role) {
      return res.status(400).json({ code: 400, message: '用户ID和申请角色为必填字段' });
    }

    // 校验用户ID格式
    if (!mongoose.Types.ObjectId.isValid(user_id)) {
      return res.status(400).json({ code: 400, message: '用户ID格式无效' });
    }

    // 检查用户是否存在
    const userExists = await User.exists({ _id: user_id });
    if (!userExists) {
      return res.status(404).json({ code: 404, message: '用户不存在' });
    }

    // 校验申请角色有效性（与Application模型的enum一致）
    const validRoles = [1, 2, 3];
    if (!validRoles.includes(applied_role)) {
      return res.status(400).json({ 
        code: 400, 
        message: '申请角色必须为 1（客服）、2（站点）、3（维修员）' 
      });
    }

    // 检查是否有未处理的申请
    const pendingApplication = await Application.findOne({ 
      user_id, 
      status: '待审核' 
    });
    if (pendingApplication) {
      return res.status(409).json({ 
        code: 409, 
        message: '存在未处理的权限申请，请勿重复提交' 
      });
    }

    // 创建申请记录
    const newApplication = new Application({ user_id, applied_role, application_type: 'role_upgrade'});
    await newApplication.save();

    res.status(201).json({ 
      code: 201, 
      message: '权限申请提交成功', 
      data: newApplication 
    });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});

// 12. 申请单列表接口（查询权限申请记录）
router.get('/applications', async (req, res) => {
  try {
    const { status, user_id } = req.query;
    const query = {};

    // 按状态筛选（可选）
    if (status) {
      const validStatus = ['待审核', '已通过', '已拒绝'];
      if (!validStatus.includes(status)) {
        return res.status(400).json({ 
          code: 400, 
          message: '状态必须为 待审核、已通过、已拒绝' 
        });
      }
      query.status = status;
    }

    // 按用户ID筛选（可选）
    if (user_id) {
      if (!mongoose.Types.ObjectId.isValid(user_id)) {
        return res.status(400).json({ code: 400, message: '用户ID格式无效' });
      }
      query.user_id = user_id;
    }

    // 查询并关联用户信息（排除密码字段）
    const applications = await Application.find(query)
      .populate('user_id', '-password') // 关联用户表，排除密码
      .sort({ createdAt: -1 }); // 按申请时间倒序排列

    res.json({ code: 200, data: applications });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});

// 13. 维修员创建加入站点申请接口
router.post('/station-membership-applications', async (req, res) => {
  try {
    const { user_id, station_id, remark } = req.body;

    // 校验必填参数
    if (!user_id || !station_id) {
      return res.status(400).json({ code: 400, message: '用户ID和目标站点ID为必填字段' });
    }

    // 校验ID格式
    if (!mongoose.Types.ObjectId.isValid(user_id) || !mongoose.Types.ObjectId.isValid(station_id)) {
      return res.status(400).json({ code: 400, message: '用户ID或站点ID格式无效' });
    }

    // 检查用户是否为维修员（role=3）
    const user = await User.findById(user_id);
    if (!user) return res.status(404).json({ code: 404, message: '用户不存在' });
    if (user.role !== 3) {
      return res.status(400).json({ code: 400, message: '仅维修员可提交加入站点申请' });
    }

    // 检查目标站点是否存在（role=2）
    const station = await User.findById(station_id);
    if (!station || station.role !== 2) {
      return res.status(404).json({ code: 404, message: '目标站点不存在' });
    }

    // 检查是否有未处理的申请
    const pendingApplication = await Application.findOne({ 
      user_id, 
      application_type: 'station_membership', 
      status: '待审核' 
    });
    if (pendingApplication) {
      return res.status(409).json({ 
        code: 409, 
        message: '存在未处理的加入站点申请，请勿重复提交' 
      });
    }

    // 创建申请记录（需扩展Application模型）
    const newApplication = new Application({
      user_id,
      station_id, // 关联目标站点ID
      application_type: 'station_membership', // 区分权限升级和加入站点
      remark, // 可选备注
      status: '待审核'
    });
    await newApplication.save();

    res.status(201).json({ 
      code: 201, 
      message: '加入站点申请提交成功', 
      data: newApplication 
    });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});


// 14. 拒绝权限/站点申请接口（管理员/站点审核）
router.put('/applications/:id/reject', async (req, res) => {
  try {
    const { id: applicationId } = req.params; // 申请单ID
  

    // 校验申请单ID格式
    if (!mongoose.Types.ObjectId.isValid(applicationId)) {
      return res.status(400).json({ code: 400, message: '无效的申请单ID格式' });
    }

    // 查询待审核的申请单
    const application = await Application.findById(applicationId);
    if (!application) {
      return res.status(404).json({ code: 404, message: '申请单不存在' });
    }
    if (application.status !== '待审核') {
      return res.status(400).json({ code: 400, message: '仅允许拒绝状态为"待审核"的申请' });
    }

    // 更新申请状态和拒绝原因
    application.status = '已拒绝';
    await application.save();

    res.json({ 
      code: 200, 
      message: '申请拒绝成功', 
      data: application 
    });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});
// 15. 管理员通过站点申请接口
router.put('/applications/:id/approve', async (req, res) => {
  try {
    const { id: applicationId } = req.params; // 申请单ID

    // 校验申请单ID格式
    if (!mongoose.Types.ObjectId.isValid(applicationId)) {
      return res.status(400).json({ code: 400, message: '无效的申请单ID格式' });
    }

    // 查询待审核的申请单（同时关联用户和站点信息）
    const application = await Application.findById(applicationId)
      .populate('user_id', '-password')
      .populate('station_id', '-password');

    if (!application) {
      return res.status(404).json({ code: 404, message: '申请单不存在' });
    }
    if (application.status !== '待审核') {
      return res.status(400).json({ code: 400, message: '仅允许通过状态为"待审核"的申请' });
    }

    // 处理不同类型的申请
    if (application.application_type === 'station_membership') {
      // 验证站点是否存在（防止站点被删除后仍处理申请）
      if (!application.station_id) {
        return res.status(404).json({ code: 404, message: '目标站点已不存在' });
      }

      // 验证维修员是否存在（防止用户被删除后仍处理申请）
      if (!application.user_id) {
        return res.status(404).json({ code: 404, message: '申请用户已不存在' });
      }

      // 将维修员添加到站点的员工列表（避免重复添加）
      if (!application.station_id.employees.includes(application.user_id._id)) {
        application.station_id.employees.push(application.user_id._id);
        await application.station_id.save();
      }
    }

    // 更新申请状态为已通过
    application.status = '已通过';
    await application.save();

    res.json({ 
      code: 200, 
      message: '申请通过成功', 
      data: {
        application,
        station: application.application_type === 'station_membership' ? application.station_id : null
      } 
    });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});

module.exports = router;
